// 内部可变性(Cell和RefCell)
// 可以在拥有不可变引用的同时修改目标数据

pub fn learn_cell() {
  //_learn_cell0();
  // _learn_refcell0();
  _learn_rc_refcell0();
}

// Cell
// Cell和RefCell在功能上没有区别,区别在于Cell<T>适用于T实现Copy的情况

use std::cell::{Cell, RefCell};

fn _learn_cell0() {
  let c = Cell::new("asdf"); // "asdf"是&str类型,它实现了 Copy 特征
  let one = c.get(); // c.get()用来取值
  c.set("qwer"); // c.set()用来设置新值
  let two = c.get();
  println!("{}, {}", one, two);
  // 取到值保存在one变量后,还能同时进行修改,这违反了rust的借用规则,但是Cell支持这样做.

  // 如果没有实现Copy特征的,则会报错
  let d = Cell::new(String::from("hello"));
  // let t = d.get(); 报错,因为String没有实现Copy
}

// RefCell
// Cell类型 针对的是实现了Copy特征的值类型,因此在实际开发中,Cell用得并不多,因为我们要解决的
// 往往是可变,不可变引用共存导致的问题,此时就需要借助于 RefCell 来达成目的.

/*
Rust 规则                            智能指针带来的额外规则
一个数据只有一个所有者               Rc/Arc 让一个数据可以拥有多个所有者
要么多个不可变借用,要么一个可变借用    RefCell 实现编译期可变,不可变引用共存
违背规则导致 编译错误                违背规则导致运行时 panic
*/

fn _learn_refcell0() {
  let s = RefCell::new(String::from("hello"));
  let s1 = s.borrow();

  // 利用RefCell推迟了编译期借用检查,但运行时依然报错 panic: BorrowMutError
  let s2 = s.borrow_mut();

  println!("{},{}", s1, s2);

  // RefCell Case1: 编译器不能确定你的代码是否正确时,会判定为错误,这可能是误报
  // 你确信代码是正确的,只是编译器误报时,就可以使用RefCell
  // Case2: 代码复杂,使用RefCell使事情简化.
}

// RefCell总结:
// 1,与Cell用于可Copy的值不同, RefCell用于引用
// 2,RefCell 只是将借用规则从编译期推迟到运行时, 并不能帮你绕过这个规则
// 3,RefCell 适用于编译期误报或者一个引用被在多处代码使用,修改以至于难以管理借用关系时
// 4,使用RefCell时,违背借用规则会导致运行期的 panic

fn _learn_cell1() {
  let x = Cell::new(1);
  let y = &x;
  let z = &x;
  x.set(2);
  y.set(3);
  z.set(4);
  println!("{}", x.get());

  let mut x = 1;
  let y = &mut x;

  // cannot borrow 'x' as mutable more than once at a time; second mutable borrow occurs here
  // let z=&mut x;

  // cannot assign to 'x' because it's borrowed. 'x' is assigned to here but it was already borrwed
  // x = 2;

  *y = 3;
  // *z = 4;
  println!("{}", x);
}

// 内部可变性
// Rust的基本借用规则,不允许对一个不可变值进行可变借用.因为一个不可变的值可以拥有多个不可变的引用,
// 此时若将其中一个修改为可变的,会造成可变引用与不可变引用共存.违反了Rust的借用规则.
// 而可变的值最多只会有一个可变引用,将其修改为不可变引用,最终只有一个不可变引用指向它,不违反Rust的
// 借用规则.
// 某些场景下,允许一个值在其方法内部可变,同时对其他代码不可变.

// 定义在外部库中的特征
pub trait Messenger {
  // 发送消息的发送器本身不可变
  fn send(&self, msg: String);
}
// -------------
// 我们的代码中的数据结构和实现
struct MsgQueue {
  // 具体实现时,希望先将消息写入缓存,然后再批量发送出去
  // 写入缓存需要可变引用,这里就编译报错了
  // msg_cache: Vec<String>,
  // 改为RefCell,将 &self 中的msg_cache 成为一个可变值,实现对其的修改.
  msg_cache: RefCell<Vec<String>>,
}

impl Messenger for MsgQueue {
  fn send(&self, msg: String) {
    // self.msg_cache.push(msg) // can't borrow 'self.msg_cache' as mutable, as it's behind a '&' refence
    self.msg_cache.borrow_mut().push(msg)
  }
}

// Rc+RefCell组合使用
use std::rc::Rc;
fn _learn_rc_refcell0() {
  let s = Rc::new(RefCell::new("我很善变,还拥有多个主人".to_string()));
  // let s = Rc::new("我很善变,还拥有多个主人".to_string());

  let s1 = s.clone();
  let s2 = s.clone();
  // let mut s2=s.borrow_mut();
  s2.borrow_mut().push_str(", oh yeah!");
  // s2.push_str("hello"); // can't mutable immutable 's2'
  println!("{:?}\n{:?}\n{:?}", s, s1, s2);

  // RefCell 包裹了字符串,又通过Rc创建了它的三个所有者,s,s1,s2.并通过其中一个所有者对字符串内容
  // 进行了修改.由于Rc的所有者们共享同一额底层的数据,因此当一个所有者修改了数据时,会导致全部所有者
  // 持有的数据都发生了变化.
}

fn is_even(i: i32) -> bool {
  i % 2 == 0
}
fn retain_even(nums: &mut Vec<i32>) {
  let mut i = 0;
  for num in nums.iter().filter(|&num| is_even(*num)) {
    // nums.iter() 这里发生了不可变借用
    // nums[i]=*num; // error:can't borrow '*nums' as mutable because it's also borrowed as immutable
    i += 1;
  }
}

// 解决方案1,通过索引的方式来避免这个问题
fn _retain_even1(nums: &mut Vec<i32>) {
  let mut i = 0;
  for j in 0..nums.len() {
    if is_even(nums[j]) {
      nums[i] = nums[j];
      i += 1;
    }
  }
}

// Rust 1.37 新增方法
// 1,Cell::from_mut 将 &mut T 转为 &Cell<T>
// 2,Cell::as_slice_of_cells, 将 &Cell<[T]> 转为 &[Cell<T>]
fn _retain_even2(nums: &mut Vec<i32>) {
  let slice: &[Cell<i32>] = Cell::from_mut(&mut nums[..]).as_slice_of_cells();
  let mut i = 0;
  for num in slice.iter().filter(|num| is_even(num.get())) {
    slice[i].set(num.get());
    i += 1;
  }
}

// Cell和RefCell都为我们带来了内部可变性这个重要特性,同时还将借用规则的检查从编译期推迟到
// 运行期,但是这个检查并不能被绕过, RefCell 在运行期的报错会造成panic.
// RefCell 适用于编译器误报 或者一个引用被在多个代码中使用,修改,以至于难以管理借用关系时.
// 还有就是需要内部可变性时.

// Rc跟RefCell结合使用可以实现多个所有者共享同一份数据,非常好用,但是潜在的性能损耗也要考虑
// 进去,建议对热点代码使用时,做好benchmark.
